ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಇನ್‌ಫರ್‌ನಲ್ಲಿ ಪರಿಣತಿ: ಸುಧಾರಿತ ಟೈಪ್ ಮ್ಯಾನಿಪ್ಯುಲೇಶನ್‌ಗಾಗಿ ಷರತ್ತುಬದ್ಧ ಟೈಪ್ ಎಕ್ಸ್‌ಟ್ರಾಕ್ಷನ್

ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್‌ನ ಟೈಪ್ ಸಿಸ್ಟಮ್ ಅತ್ಯಂತ ಶಕ್ತಿಯುತವಾಗಿದ್ದು, ಡೆವಲಪರ್‌ಗಳಿಗೆ ದೃಢವಾದ ಮತ್ತು ನಿರ್ವಹಿಸಬಲ್ಲ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ರಚಿಸಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ. ಈ ಶಕ್ತಿಯನ್ನು ಸಕ್ರಿಯಗೊಳಿಸುವ ಪ್ರಮುಖ ವೈಶಿಷ್ಟ್ಯವೆಂದರೆ infer ಕೀವರ್ಡ್ ಅನ್ನು ಷರತ್ತುಬದ್ಧ ಟೈಪ್‌ಗಳೊಂದಿಗೆ ಬಳಸುವುದು. ಈ ಸಂಯೋಜನೆಯು ಸಂಕೀರ್ಣ ಟೈಪ್ ರಚನೆಗಳಿಂದ ನಿರ್ದಿಷ್ಟ ಟೈಪ್‌ಗಳನ್ನು ಹೊರತೆಗೆಯಲು ಒಂದು ವ್ಯವಸ್ಥೆಯನ್ನು ಒದಗಿಸುತ್ತದೆ. ಈ ಬ್ಲಾಗ್ ಪೋಸ್ಟ್ infer ಕೀವರ್ಡ್‌ನ ಆಳವಾದ ವಿವರಣೆಯನ್ನು ನೀಡುತ್ತದೆ, ಅದರ ಕಾರ್ಯಚಟುವಟಿಕೆಯನ್ನು ವಿವರಿಸುತ್ತದೆ ಮತ್ತು ಸುಧಾರಿತ ಬಳಕೆಯ ಪ್ರಕರಣಗಳನ್ನು ಪ್ರದರ್ಶಿಸುತ್ತದೆ. API ಸಂವಹನದಿಂದ ಸಂಕೀರ್ಣ ಡೇಟಾ ರಚನೆಯ ಮ್ಯಾನಿಪ್ಯುಲೇಶನ್‌ವರೆಗೆ, ವಿವಿಧ ಸಾಫ್ಟ್‌ವೇರ್ ಅಭಿವೃದ್ಧಿ ಸನ್ನಿವೇಶಗಳಿಗೆ ಅನ್ವಯವಾಗುವ ಪ್ರಾಯೋಗಿಕ ಉದಾಹರಣೆಗಳನ್ನು ನಾವು ಅನ್ವೇಷಿಸುತ್ತೇವೆ.

ಷರತ್ತುಬದ್ಧ ಟೈಪ್‌ಗಳು ಎಂದರೇನು?

ನಾವು infer ಬಗ್ಗೆ ತಿಳಿಯುವ ಮೊದಲು, ಷರತ್ತುಬದ್ಧ ಟೈಪ್‌ಗಳನ್ನು ತ್ವರಿತವಾಗಿ ಪರಿಶೀಲಿಸೋಣ. ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿನ ಷರತ್ತುಬದ್ಧ ಟೈಪ್‌ಗಳು, ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿನ ಟರ್ನರಿ ಆಪರೇಟರ್‌ನಂತೆ, ಒಂದು ಷರತ್ತಿನ ಆಧಾರದ ಮೇಲೆ ಟೈಪ್ ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ. ಇದರ ಮೂಲ ಸಿಂಟ್ಯಾಕ್ಸ್ ಹೀಗಿದೆ:

T extends U ? X : Y

ಇದನ್ನು ಹೀಗೆ ಓದಲಾಗುತ್ತದೆ: "ಒಂದು ವೇಳೆ ಟೈಪ್ T ಯು ಟೈಪ್ U ಗೆ ನಿಯೋಜಿಸಬಹುದಾದರೆ, ಆಗ ಟೈಪ್ X ಆಗಿರುತ್ತದೆ; ಇಲ್ಲದಿದ್ದರೆ, ಟೈಪ್ Y ಆಗಿರುತ್ತದೆ."

ಉದಾಹರಣೆ:

type IsString<T> = T extends string ? true : false;

type StringResult = IsString<string>; // type StringResult = true
type NumberResult = IsString<number>; // type NumberResult = false

infer ಕೀವರ್ಡ್‌ನ ಪರಿಚಯ

infer ಕೀವರ್ಡ್ ಅನ್ನು ಷರತ್ತುಬದ್ಧ ಟೈಪ್‌ನ extends ಕ್ಲಾಸ್‌ನಲ್ಲಿ ಬಳಸಲಾಗುತ್ತದೆ, ಇದು ಪರಿಶೀಲಿಸಲಾಗುತ್ತಿರುವ ಟೈಪ್‌ನಿಂದ ನಿರ್ಣಯಿಸಬಹುದಾದ ಟೈಪ್ ವೇರಿಯೇಬಲ್ ಅನ್ನು ಘೋಷಿಸುತ್ತದೆ. ಮೂಲಭೂತವಾಗಿ, ಇದು ನಂತರದ ಬಳಕೆಗಾಗಿ ಟೈಪ್‌ನ ಒಂದು ಭಾಗವನ್ನು "ಸೆರೆಹಿಡಿಯಲು" ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ.

ಮೂಲ ಸಿಂಟ್ಯಾಕ್ಸ್:

type MyType<T> = T extends (infer U) ? U : never;

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, Tಯು ಯಾವುದಾದರೂ ಟೈಪ್‌ಗೆ ನಿಯೋಜಿಸಬಹುದಾದರೆ, ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ U ನ ಟೈಪ್ ಅನ್ನು ನಿರ್ಣಯಿಸಲು ಪ್ರಯತ್ನಿಸುತ್ತದೆ. ನಿರ್ಣಯ ಯಶಸ್ವಿಯಾದರೆ, ಟೈಪ್ U ಆಗಿರುತ್ತದೆ; ಇಲ್ಲದಿದ್ದರೆ, ಅದು never ಆಗಿರುತ್ತದೆ.

infer ನ ಸರಳ ಉದಾಹರಣೆಗಳು

1. ಫಂಕ್ಷನ್‌ನ ರಿಟರ್ನ್ ಟೈಪ್ ಅನ್ನು ನಿರ್ಣಯಿಸುವುದು

ಒಂದು ಸಾಮಾನ್ಯ ಬಳಕೆಯೆಂದರೆ ಫಂಕ್ಷನ್‌ನ ರಿಟರ್ನ್ ಟೈಪ್ ಅನ್ನು ನಿರ್ಣಯಿಸುವುದು:

type ReturnType<T extends (...args: any) => any> = T extends (...args: any) => infer R ? R : any;

function add(a: number, b: number): number {
  return a + b;
}

type AddReturnType = ReturnType<typeof add>; // type AddReturnType = number

function greet(name: string): string {
  return `Hello, ${name}!`;
}

type GreetReturnType = ReturnType<typeof greet>; // type GreetReturnType = string

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, ReturnType<T> ಇನ್‌ಪುಟ್ ಆಗಿ ಫಂಕ್ಷನ್ ಟೈಪ್ T ಅನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ. ಇದು T ಯಾವುದೇ ಆರ್ಗ್ಯುಮೆಂಟ್‌ಗಳನ್ನು ಸ್ವೀಕರಿಸುವ ಮತ್ತು ಮೌಲ್ಯವನ್ನು ಹಿಂದಿರುಗಿಸುವ ಫಂಕ್ಷನ್‌ಗೆ ನಿಯೋಜಿಸಬಹುದೇ ಎಂದು ಪರಿಶೀಲಿಸುತ್ತದೆ. ಹಾಗಿದ್ದರೆ, ಅದು ರಿಟರ್ನ್ ಟೈಪ್ ಅನ್ನು R ಎಂದು ನಿರ್ಣಯಿಸುತ್ತದೆ ಮತ್ತು ಅದನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ. ಇಲ್ಲದಿದ್ದರೆ, ಅದು any ಅನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ.

2. ಅರೇ ಎಲಿಮೆಂಟ್ ಟೈಪ್ ಅನ್ನು ನಿರ್ಣಯಿಸುವುದು

ಮತ್ತೊಂದು ಉಪಯುಕ್ತ ಸನ್ನಿವೇಶವೆಂದರೆ ಅರೇಯಿಂದ ಎಲಿಮೆಂಟ್ ಟೈಪ್ ಅನ್ನು ಹೊರತೆಗೆಯುವುದು:

type ArrayElementType<T> = T extends (infer U)[] ? U : never;

type NumberArrayType = ArrayElementType<number[]>; // type NumberArrayType = number
type StringArrayType = ArrayElementType<string[]>; // type StringArrayType = string
type MixedArrayType = ArrayElementType<(string | number)[]>; // type MixedArrayType = string | number
type NotAnArrayType = ArrayElementType<number>; // type NotAnArrayType = never

ಇಲ್ಲಿ, ArrayElementType<T> ಯು T ಅರೇ ಟೈಪ್ ಆಗಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸುತ್ತದೆ. ಹಾಗಿದ್ದರೆ, ಅದು ಎಲಿಮೆಂಟ್ ಟೈಪ್ ಅನ್ನು U ಎಂದು ನಿರ್ಣಯಿಸುತ್ತದೆ ಮತ್ತು ಅದನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ. ಇಲ್ಲದಿದ್ದರೆ, ಅದು never ಅನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ.

infer ನ ಸುಧಾರಿತ ಬಳಕೆಯ ಪ್ರಕರಣಗಳು

1. ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್‌ನ ಪ್ಯಾರಾಮೀಟರ್‌ಗಳನ್ನು ನಿರ್ಣಯಿಸುವುದು

ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್ ಫಂಕ್ಷನ್‌ನ ಪ್ಯಾರಾಮೀಟರ್ ಟೈಪ್‌ಗಳನ್ನು ಹೊರತೆಗೆಯಲು ನೀವು infer ಅನ್ನು ಬಳಸಬಹುದು:

type ConstructorParameters<T extends new (...args: any) => any> = T extends new (...args: infer P) => any ? P : never;

class Person {
  constructor(public name: string, public age: number) {}
}

type PersonConstructorParams = ConstructorParameters<typeof Person>; // type PersonConstructorParams = [string, number]

class Point {
    constructor(public x: number, public y: number) {}
}

type PointConstructorParams = ConstructorParameters<typeof Point>; // type PointConstructorParams = [number, number]

ಈ ಸಂದರ್ಭದಲ್ಲಿ, ConstructorParameters<T> ಒಂದು ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್ ಫಂಕ್ಷನ್ ಟೈಪ್ T ಅನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ. ಇದು ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್ ಪ್ಯಾರಾಮೀಟರ್‌ಗಳ ಟೈಪ್‌ಗಳನ್ನು P ಎಂದು ನಿರ್ಣಯಿಸುತ್ತದೆ ಮತ್ತು ಅವುಗಳನ್ನು ಟಪಲ್ (tuple) ಆಗಿ ಹಿಂದಿರುಗಿಸುತ್ತದೆ.

2. ಆಬ್ಜೆಕ್ಟ್ ಟೈಪ್‌ಗಳಿಂದ ಪ್ರಾಪರ್ಟಿಗಳನ್ನು ಹೊರತೆಗೆಯುವುದು

ಮ್ಯಾಪ್ ಮಾಡಲಾದ ಟೈಪ್‌ಗಳು ಮತ್ತು ಷರತ್ತುಬದ್ಧ ಟೈಪ್‌ಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಆಬ್ಜೆಕ್ಟ್ ಟೈಪ್‌ಗಳಿಂದ ನಿರ್ದಿಷ್ಟ ಪ್ರಾಪರ್ಟಿಗಳನ್ನು ಹೊರತೆಗೆಯಲು infer ಅನ್ನು ಬಳಸಬಹುದು:

type PickByType<T, K extends keyof T, U> = {
  [P in K as T[P] extends U ? P : never]: T[P];
};

interface User {
  id: number;
  name: string;
  age: number;
  email: string;
  isActive: boolean;
}

type StringProperties = PickByType<User, keyof User, string>; // type StringProperties = { name: string; email: string; }

type NumberProperties = PickByType<User, keyof User, number>; // type NumberProperties = { id: number; age: number; }

//ಭೌಗೋಳಿಕ ನಿರ್ದೇಶಾಂಕಗಳನ್ನು ಪ್ರತಿನಿಧಿಸುವ ಒಂದು ಇಂಟರ್ಫೇಸ್.
interface GeoCoordinates {
    latitude: number;
    longitude: number;
    altitude: number;
    country: string;
    city: string;
    timezone: string;
}

type NumberCoordinateProperties = PickByType<GeoCoordinates, keyof GeoCoordinates, number>; // type NumberCoordinateProperties = { latitude: number; longitude: number; altitude: number; }

ಇಲ್ಲಿ, PickByType<T, K, U> ಒಂದು ಹೊಸ ಟೈಪ್ ಅನ್ನು ರಚಿಸುತ್ತದೆ, ಅದು T ನ (K ನಲ್ಲಿನ ಕೀಗಳೊಂದಿಗೆ) ಪ್ರಾಪರ್ಟಿಗಳನ್ನು ಮಾತ್ರ ಒಳಗೊಂಡಿರುತ್ತದೆ, ಅದರ ಮೌಲ್ಯಗಳು ಟೈಪ್ U ಗೆ ನಿಯೋಜಿಸಬಹುದಾಗಿದೆ. ಮ್ಯಾಪ್ ಮಾಡಲಾದ ಟೈಪ್ T ನ ಕೀಗಳ ಮೇಲೆ ಪುನರಾವರ್ತಿಸುತ್ತದೆ, ಮತ್ತು ಷರತ್ತುಬದ್ಧ ಟೈಪ್ ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಟೈಪ್‌ಗೆ ಹೊಂದಿಕೆಯಾಗದ ಕೀಗಳನ್ನು ಫಿಲ್ಟರ್ ಮಾಡುತ್ತದೆ.

3. ಪ್ರಾಮಿಸ್‌ಗಳೊಂದಿಗೆ (Promises) ಕೆಲಸ ಮಾಡುವುದು

ನೀವು ಒಂದು Promise ನ ರಿಸಾಲ್ವ್ಡ್ ಟೈಪ್ (resolved type) ಅನ್ನು ನಿರ್ಣಯಿಸಬಹುದು:

type Awaited<T> = T extends Promise<infer U> ? U : T;

async function fetchData(): Promise<string> {
  return 'Data from API';
}

type FetchDataType = Awaited<ReturnType<typeof fetchData>>; // type FetchDataType = string

async function fetchNumbers(): Promise<number[]> {
    return [1, 2, 3];
}

type FetchedNumbersType = Awaited<ReturnType<typeof fetchNumbers>>; //type FetchedNumbersType = number[]

Awaited<T> ಟೈಪ್ ಒಂದು ಟೈಪ್ T ಅನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ, ಅದು ಒಂದು Promise ಆಗಿರುತ್ತದೆ ಎಂದು ನಿರೀಕ್ಷಿಸಲಾಗಿದೆ. ನಂತರ ಟೈಪ್, Promise ನ ರಿಸಾಲ್ವ್ಡ್ ಟೈಪ್ U ಅನ್ನು ನಿರ್ಣಯಿಸುತ್ತದೆ ಮತ್ತು ಅದನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ. ಒಂದು ವೇಳೆ T ಪ್ರಾಮಿಸ್ ಆಗದಿದ್ದರೆ, ಅದು T ಅನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ. ಇದು ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್‌ನ ಹೊಸ ಆವೃತ್ತಿಗಳಲ್ಲಿ ಒಂದು ಅಂತರ್ನಿರ್ಮಿತ ಯುಟಿಲಿಟಿ ಟೈಪ್ ಆಗಿದೆ.

4. ಪ್ರಾಮಿಸ್‌ಗಳ ಅರೇಯ ಟೈಪ್ ಅನ್ನು ಹೊರತೆಗೆಯುವುದು

Awaited ಮತ್ತು ಅರೇ ಟೈಪ್ ನಿರ್ಣಯವನ್ನು ಸಂಯೋಜಿಸುವುದರಿಂದ ಪ್ರಾಮಿಸ್‌ಗಳ ಅರೇಯಿಂದ ರಿಸಾಲ್ವ್ ಆಗುವ ಟೈಪ್ ಅನ್ನು ನಿರ್ಣಯಿಸಲು ನಿಮಗೆ ಸಾಧ್ಯವಾಗುತ್ತದೆ. ಇದು Promise.all ನೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವಾಗ ವಿಶೇಷವಾಗಿ ಉಪಯುಕ್ತವಾಗಿದೆ.

type PromiseArrayReturnType<T extends Promise<any>[]> = {
    [K in keyof T]: Awaited<T[K]>;
};


async function getUSDRate(): Promise<number> {
  return 0.0069;
}

async function getEURRate(): Promise<number> {
  return 0.0064;
}

const rates = [getUSDRate(), getEURRate()];

type RatesType = PromiseArrayReturnType<typeof rates>;
// type RatesType = [number, number]

ಈ ಉದಾಹರಣೆಯು ಮೊದಲು ಎರಡು ಅಸಿಂಕ್ರೊನಸ್ ಫಂಕ್ಷನ್‌ಗಳಾದ getUSDRate ಮತ್ತು getEURRate ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತದೆ, ಇದು ವಿನಿಮಯ ದರಗಳನ್ನು ಪಡೆಯುವುದನ್ನು ಅನುಕರಿಸುತ್ತದೆ. ನಂತರ PromiseArrayReturnType ಯುಟಿಲಿಟಿ ಟೈಪ್ ಅರೇಯಲ್ಲಿನ ಪ್ರತಿಯೊಂದು Promise ನಿಂದ ರಿಸಾಲ್ವ್ಡ್ ಟೈಪ್ ಅನ್ನು ಹೊರತೆಗೆಯುತ್ತದೆ, ಇದರ ಪರಿಣಾಮವಾಗಿ ಒಂದು ಟಪಲ್ ಟೈಪ್ ಆಗುತ್ತದೆ, ಅಲ್ಲಿ ಪ್ರತಿಯೊಂದು ಎಲಿಮೆಂಟ್ ಅನುಗುಣವಾದ Promise ನ ನಿರೀಕ್ಷಿತ (awaited) ಟೈಪ್ ಆಗಿರುತ್ತದೆ.

ವಿವಿಧ ಡೊಮೇನ್‌ಗಳಲ್ಲಿ ಪ್ರಾಯೋಗಿಕ ಉದಾಹರಣೆಗಳು

1. ಇ-ಕಾಮರ್ಸ್ ಅಪ್ಲಿಕೇಶನ್

ಒಂದು ಇ-ಕಾಮರ್ಸ್ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಪರಿಗಣಿಸಿ, ಅಲ್ಲಿ ನೀವು API ನಿಂದ ಉತ್ಪನ್ನದ ವಿವರಗಳನ್ನು ಪಡೆಯುತ್ತೀರಿ. ಉತ್ಪನ್ನ ಡೇಟಾದ ಟೈಪ್ ಅನ್ನು ಹೊರತೆಗೆಯಲು ನೀವು infer ಅನ್ನು ಬಳಸಬಹುದು:

interface Product {
  id: number;
  name: string;
  price: number;
  description: string;
  imageUrl: string;
  category: string;
  rating: number;
  countryOfOrigin: string;
}

async function fetchProduct(productId: number): Promise<Product> {
  // API ಕರೆಯನ್ನು ಅನುಕರಿಸುವುದು
  return new Promise((resolve) => {
    setTimeout(() => {
      resolve({
        id: productId,
        name: 'Example Product',
        price: 29.99,
        description: 'A sample product',
        imageUrl: 'https://example.com/image.jpg',
        category: 'Electronics',
        rating: 4.5,
        countryOfOrigin: 'Canada'
      });
    }, 500);
  });
}


type ProductType = Awaited<ReturnType<typeof fetchProduct>>; // type ProductType = Product

function displayProductDetails(product: ProductType) {
  console.log(`Product Name: ${product.name}`);
  console.log(`Price: ${product.price} ${product.countryOfOrigin === 'Canada' ? 'CAD' : (product.countryOfOrigin === 'USA' ? 'USD' : 'EUR')}`);
}

fetchProduct(123).then(displayProductDetails);

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, ನಾವು Product ಇಂಟರ್ಫೇಸ್ ಮತ್ತು fetchProduct ಫಂಕ್ಷನ್ ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತೇವೆ, ಅದು API ನಿಂದ ಉತ್ಪನ್ನದ ವಿವರಗಳನ್ನು ಪಡೆಯುತ್ತದೆ. fetchProduct ಫಂಕ್ಷನ್‌ನ ರಿಟರ್ನ್ ಟೈಪ್‌ನಿಂದ Product ಟೈಪ್ ಅನ್ನು ಹೊರತೆಗೆಯಲು ನಾವು Awaited ಮತ್ತು ReturnType ಅನ್ನು ಬಳಸುತ್ತೇವೆ, ಇದು displayProductDetails ಫಂಕ್ಷನ್ ಅನ್ನು ಟೈಪ್-ಚೆಕ್ ಮಾಡಲು ನಮಗೆ ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ.

2. ಅಂತರರಾಷ್ಟ್ರೀಕರಣ (i18n)

ಸ್ಥಳೀಯತೆಗೆ (locale) ಅನುಗುಣವಾಗಿ ವಿಭಿನ್ನ ಸ್ಟ್ರಿಂಗ್‌ಗಳನ್ನು ಹಿಂದಿರುಗಿಸುವ ಒಂದು ಅನುವಾದ ಫಂಕ್ಷನ್ ನಿಮ್ಮಲ್ಲಿದೆ ಎಂದು ಭಾವಿಸೋಣ. ಟೈಪ್ ಸುರಕ್ಷತೆಗಾಗಿ ಈ ಫಂಕ್ಷನ್‌ನ ರಿಟರ್ನ್ ಟೈಪ್ ಅನ್ನು ಹೊರತೆಗೆಯಲು ನೀವು infer ಅನ್ನು ಬಳಸಬಹುದು:

interface Translations {
  greeting: string;
  farewell: string;
  welcomeMessage: (name: string) => string;
}

const enTranslations: Translations = {
  greeting: 'Hello',
  farewell: 'Goodbye',
  welcomeMessage: (name: string) => `Welcome, ${name}!`, 
};

const frTranslations: Translations = {
  greeting: 'Bonjour',
  farewell: 'Au revoir',
  welcomeMessage: (name: string) => `Bienvenue, ${name}!`, 
};

function getTranslation(locale: 'en' | 'fr'): Translations {
  return locale === 'en' ? enTranslations : frTranslations;
}

type TranslationType = ReturnType<typeof getTranslation>;

function greetUser(locale: 'en' | 'fr', name: string) {
  const translations = getTranslation(locale);
  console.log(translations.welcomeMessage(name));
}

greetUser('fr', 'Jean'); // Output: Bienvenue, Jean!

ಇಲ್ಲಿ, TranslationType ಅನ್ನು Translations ಇಂಟರ್ಫೇಸ್ ಎಂದು ನಿರ್ಣಯಿಸಲಾಗುತ್ತದೆ, ಇದು greetUser ಫಂಕ್ಷನ್ ಅನುವಾದಿತ ಸ್ಟ್ರಿಂಗ್‌ಗಳನ್ನು ಪ್ರವೇಶಿಸಲು ಸರಿಯಾದ ಟೈಪ್ ಮಾಹಿತಿಯನ್ನು ಹೊಂದಿದೆ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ.

3. API ಪ್ರತಿಕ್ರಿಯೆ ನಿರ್ವಹಣೆ

API ಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವಾಗ, ಪ್ರತಿಕ್ರಿಯೆಯ ರಚನೆ ಸಂಕೀರ್ಣವಾಗಿರಬಹುದು. ನೆಸ್ಟೆಡ್ (nested) API ಪ್ರತಿಕ್ರಿಯೆಗಳಿಂದ ನಿರ್ದಿಷ್ಟ ಡೇಟಾ ಟೈಪ್‌ಗಳನ್ನು ಹೊರತೆಗೆಯಲು infer ಸಹಾಯ ಮಾಡುತ್ತದೆ:

interface ApiResponse<T> {
  status: number;
  data: T;
  message?: string;
}

interface UserData {
  id: number;
  username: string;
  email: string;
  profile: {
    firstName: string;
    lastName: string;
    country: string;
    language: string;
  }
}

async function fetchUser(userId: number): Promise<ApiResponse<UserData>> {
  // API ಕರೆಯನ್ನು ಅನುಕರಿಸುವುದು
  return new Promise((resolve) => {
    setTimeout(() => {
      resolve({
        status: 200,
        data: {
          id: userId,
          username: 'johndoe',
          email: 'john.doe@example.com',
          profile: {
            firstName: 'John',
            lastName: 'Doe',
            country: 'USA',
            language: 'en'
          }
        }
      });
    }, 500);
  });
}


type UserApiResponse = Awaited<ReturnType<typeof fetchUser>>;

type UserProfileType = UserApiResponse['data']['profile'];

function displayUserProfile(profile: UserProfileType) {
  console.log(`Name: ${profile.firstName} ${profile.lastName}`);
  console.log(`Country: ${profile.country}`);
}

fetchUser(123).then((response) => {
  if (response.status === 200) {
    displayUserProfile(response.data.profile);
  }
});

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, ನಾವು ApiResponse ಇಂಟರ್ಫೇಸ್ ಮತ್ತು UserData ಇಂಟರ್ಫೇಸ್ ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತೇವೆ. API ಪ್ರತಿಕ್ರಿಯೆಯಿಂದ UserProfileType ಅನ್ನು ಹೊರತೆಗೆಯಲು ನಾವು infer ಮತ್ತು ಟೈಪ್ ಇಂಡೆಕ್ಸಿಂಗ್ ಅನ್ನು ಬಳಸುತ್ತೇವೆ, ಇದು displayUserProfile ಫಂಕ್ಷನ್ ಸರಿಯಾದ ಟೈಪ್ ಅನ್ನು ಪಡೆಯುತ್ತದೆ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ.

infer ಬಳಸಲು ಉತ್ತಮ ಅಭ್ಯಾಸಗಳು

• ಸರಳವಾಗಿಡಿ: ಅಗತ್ಯವಿದ್ದಾಗ ಮಾತ್ರ infer ಬಳಸಿ. ಅದರ ಅತಿಯಾದ ಬಳಕೆಯು ನಿಮ್ಮ ಕೋಡ್ ಅನ್ನು ಓದಲು ಮತ್ತು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಕಷ್ಟಕರವಾಗಿಸುತ್ತದೆ.
• ನಿಮ್ಮ ಟೈಪ್‌ಗಳನ್ನು ದಾಖಲಿಸಿ: ನಿಮ್ಮ ಷರತ್ತುಬದ್ಧ ಟೈಪ್‌ಗಳು ಮತ್ತು infer ಸ್ಟೇಟ್‌ಮೆಂಟ್‌ಗಳು ಏನು ಮಾಡುತ್ತವೆ ಎಂಬುದನ್ನು ವಿವರಿಸಲು ಕಾಮೆಂಟ್‌ಗಳನ್ನು ಸೇರಿಸಿ.
• ನಿಮ್ಮ ಟೈಪ್‌ಗಳನ್ನು ಪರೀಕ್ಷಿಸಿ: ನಿಮ್ಮ ಟೈಪ್‌ಗಳು ನಿರೀಕ್ಷೆಯಂತೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತಿವೆಯೇ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್‌ನ ಟೈಪ್ ಪರಿಶೀಲನೆಯನ್ನು ಬಳಸಿ.
• ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಪರಿಗಣಿಸಿ: ಸಂಕೀರ್ಣ ಷರತ್ತುಬದ್ಧ ಟೈಪ್‌ಗಳು ಕೆಲವೊಮ್ಮೆ ಕಂಪೈಲೇಶನ್ ಸಮಯದ ಮೇಲೆ ಪರಿಣಾಮ ಬೀರಬಹುದು. ನಿಮ್ಮ ಟೈಪ್‌ಗಳ ಸಂಕೀರ್ಣತೆಯ ಬಗ್ಗೆ ಗಮನವಿರಲಿ.
• ಯುಟಿಲಿಟಿ ಟೈಪ್‌ಗಳನ್ನು ಬಳಸಿ: ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಹಲವಾರು ಅಂತರ್ನಿರ್ಮಿತ ಯುಟಿಲಿಟಿ ಟೈಪ್‌ಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ (ಉದಾ., ReturnType, Awaited), ಇದು ನಿಮ್ಮ ಕೋಡ್ ಅನ್ನು ಸರಳಗೊಳಿಸಬಹುದು ಮತ್ತು ಕಸ್ಟಮ್ infer ಸ್ಟೇಟ್‌ಮೆಂಟ್‌ಗಳ ಅಗತ್ಯವನ್ನು ಕಡಿಮೆ ಮಾಡಬಹುದು.

ಸಾಮಾನ್ಯ ತಪ್ಪುಗಳು

• ತಪ್ಪಾದ ನಿರ್ಣಯ: ಕೆಲವೊಮ್ಮೆ, ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ನೀವು ನಿರೀಕ್ಷಿಸದ ಟೈಪ್ ಅನ್ನು ನಿರ್ಣಯಿಸಬಹುದು. ನಿಮ್ಮ ಟೈಪ್ ವ್ಯಾಖ್ಯಾನಗಳು ಮತ್ತು ಷರತ್ತುಗಳನ್ನು ಎರಡು ಬಾರಿ ಪರಿಶೀಲಿಸಿ.
• ವೃತ್ತಾಕಾರದ ಅವಲಂಬನೆಗಳು (Circular Dependencies): infer ಬಳಸಿ ಪುನರಾವರ್ತಿತ ಟೈಪ್‌ಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುವಾಗ ಜಾಗರೂಕರಾಗಿರಿ, ಏಕೆಂದರೆ ಅವು ವೃತ್ತಾಕಾರದ ಅವಲಂಬನೆಗಳು ಮತ್ತು ಕಂಪೈಲೇಶನ್ ದೋಷಗಳಿಗೆ ಕಾರಣವಾಗಬಹುದು.
• ಅತಿಯಾದ ಸಂಕೀರ್ಣ ಟೈಪ್‌ಗಳು: ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಮತ್ತು ನಿರ್ವಹಿಸಲು ಕಷ್ಟಕರವಾದ ಅತಿಯಾದ ಸಂಕೀರ್ಣ ಷರತ್ತುಬದ್ಧ ಟೈಪ್‌ಗಳನ್ನು ರಚಿಸುವುದನ್ನು ತಪ್ಪಿಸಿ. ಅವುಗಳನ್ನು ಚಿಕ್ಕ, ಹೆಚ್ಚು ನಿರ್ವಹಿಸಬಲ್ಲ ಟೈಪ್‌ಗಳಾಗಿ ವಿಭಜಿಸಿ.

infer ಗೆ ಪರ್ಯಾಯಗಳು

infer ಒಂದು ಶಕ್ತಿಯುತ ಸಾಧನವಾಗಿದ್ದರೂ, ಪರ್ಯಾಯ ವಿಧಾನಗಳು ಹೆಚ್ಚು ಸೂಕ್ತವಾಗಬಹುದಾದ ಸಂದರ್ಭಗಳಿವೆ:

• ಟೈಪ್ ಅಸರ್ಷನ್‌ಗಳು (Type Assertions): ಕೆಲವು ಸಂದರ್ಭಗಳಲ್ಲಿ, ಮೌಲ್ಯದ ಟೈಪ್ ಅನ್ನು ನಿರ್ಣಯಿಸುವ ಬದಲು ಅದನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ನಿರ್ದಿಷ್ಟಪಡಿಸಲು ನೀವು ಟೈಪ್ ಅಸರ್ಷನ್‌ಗಳನ್ನು ಬಳಸಬಹುದು. ಆದಾಗ್ಯೂ, ಟೈಪ್ ಅಸರ್ಷನ್‌ಗಳೊಂದಿಗೆ ಜಾಗರೂಕರಾಗಿರಿ, ಏಕೆಂದರೆ ಅವು ಟೈಪ್ ಪರಿಶೀಲನೆಯನ್ನು ಬೈಪಾಸ್ ಮಾಡಬಹುದು.
• ಟೈಪ್ ಗಾರ್ಡ್‌ಗಳು (Type Guards): ರನ್‌ಟೈಮ್ ಪರಿಶೀಲನೆಗಳ ಆಧಾರದ ಮೇಲೆ ಮೌಲ್ಯದ ಟೈಪ್ ಅನ್ನು ಸಂಕುಚಿತಗೊಳಿಸಲು ಟೈಪ್ ಗಾರ್ಡ್‌ಗಳನ್ನು ಬಳಸಬಹುದು. ರನ್‌ಟೈಮ್ ಪರಿಸ್ಥಿತಿಗಳ ಆಧಾರದ ಮೇಲೆ ವಿಭಿನ್ನ ಟೈಪ್‌ಗಳನ್ನು ನಿರ್ವಹಿಸಬೇಕಾದಾಗ ಇದು ಉಪಯುಕ್ತವಾಗಿದೆ.
• ಯುಟಿಲಿಟಿ ಟೈಪ್‌ಗಳು (Utility Types): ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಯುಟಿಲಿಟಿ ಟೈಪ್‌ಗಳ ಸಮೃದ್ಧ ಗುಂಪನ್ನು ಒದಗಿಸುತ್ತದೆ, ಅದು ಕಸ್ಟಮ್ infer ಸ್ಟೇಟ್‌ಮೆಂಟ್‌ಗಳ ಅಗತ್ಯವಿಲ್ಲದೆ ಅನೇಕ ಸಾಮಾನ್ಯ ಟೈಪ್ ಮ್ಯಾನಿಪ್ಯುಲೇಶನ್ ಕಾರ್ಯಗಳನ್ನು ನಿರ್ವಹಿಸಬಲ್ಲದು.

ತೀರ್ಮಾನ

ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿನ infer ಕೀವರ್ಡ್, ಷರತ್ತುಬದ್ಧ ಟೈಪ್‌ಗಳೊಂದಿಗೆ ಸಂಯೋಜಿಸಿದಾಗ, ಸುಧಾರಿತ ಟೈಪ್ ಮ್ಯಾನಿಪ್ಯುಲೇಶನ್ ಸಾಮರ್ಥ್ಯಗಳನ್ನು ಅನ್‌ಲಾಕ್ ಮಾಡುತ್ತದೆ. ಇದು ಸಂಕೀರ್ಣ ಟೈಪ್ ರಚನೆಗಳಿಂದ ನಿರ್ದಿಷ್ಟ ಟೈಪ್‌ಗಳನ್ನು ಹೊರತೆಗೆಯಲು ನಿಮಗೆ ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ, ಇದರಿಂದಾಗಿ ನೀವು ಹೆಚ್ಚು ದೃಢವಾದ, ನಿರ್ವಹಿಸಬಲ್ಲ ಮತ್ತು ಟೈಪ್-ಸುರಕ್ಷಿತ ಕೋಡ್ ಅನ್ನು ಬರೆಯಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ. ಫಂಕ್ಷನ್ ರಿಟರ್ನ್ ಟೈಪ್‌ಗಳನ್ನು ನಿರ್ಣಯಿಸುವುದರಿಂದ ಹಿಡಿದು ಆಬ್ಜೆಕ್ಟ್ ಟೈಪ್‌ಗಳಿಂದ ಪ್ರಾಪರ್ಟಿಗಳನ್ನು ಹೊರತೆಗೆಯುವವರೆಗೆ, ಸಾಧ್ಯತೆಗಳು ಅಪಾರ. ಈ ಮಾರ್ಗದರ್ಶಿಯಲ್ಲಿ ವಿವರಿಸಲಾದ ತತ್ವಗಳು ಮತ್ತು ಉತ್ತಮ ಅಭ್ಯಾಸಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವ ಮೂಲಕ, ನೀವು infer ಅನ್ನು ಅದರ ಸಂಪೂರ್ಣ ಸಾಮರ್ಥ್ಯಕ್ಕೆ ಬಳಸಿಕೊಳ್ಳಬಹುದು ಮತ್ತು ನಿಮ್ಮ ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಕೌಶಲ್ಯಗಳನ್ನು ಉನ್ನತೀಕರಿಸಬಹುದು. ನಿಮ್ಮ ಟೈಪ್‌ಗಳನ್ನು ದಾಖಲಿಸಲು, ಅವುಗಳನ್ನು ಸಂಪೂರ್ಣವಾಗಿ ಪರೀಕ್ಷಿಸಲು ಮತ್ತು ಸೂಕ್ತವಾದಾಗ ಪರ್ಯಾಯ ವಿಧಾನಗಳನ್ನು ಪರಿಗಣಿಸಲು ಮರೆಯದಿರಿ. infer ನಲ್ಲಿ ಪರಿಣತಿ ಸಾಧಿಸುವುದು ನಿಮಗೆ ನಿಜವಾಗಿಯೂ ಅಭಿವ್ಯಕ್ತಿಶೀಲ ಮತ್ತು ಶಕ್ತಿಯುತ ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಕೋಡ್ ಬರೆಯಲು ಅಧಿಕಾರ ನೀಡುತ್ತದೆ, ಅಂತಿಮವಾಗಿ ಉತ್ತಮ ಸಾಫ್ಟ್‌ವೇರ್‌ಗೆ ಕಾರಣವಾಗುತ್ತದೆ.